{"componentChunkName":"component---src-templates-blog-page-index-tsx","path":"/sistema-de-swap-estavel-amm/","result":{"data":{"mdx":{"body":"var _excluded = [\"components\"];\n\nfunction _extends() { _extends = Object.assign ? Object.assign.bind() : function (target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i]; for (var key in source) { if (Object.prototype.hasOwnProperty.call(source, key)) { target[key] = source[key]; } } } return target; }; return _extends.apply(this, arguments); }\n\nfunction _objectWithoutProperties(source, excluded) { if (source == null) return {}; var target = _objectWithoutPropertiesLoose(source, excluded); var key, i; if (Object.getOwnPropertySymbols) { var sourceSymbolKeys = Object.getOwnPropertySymbols(source); for (i = 0; i < sourceSymbolKeys.length; i++) { key = sourceSymbolKeys[i]; if (excluded.indexOf(key) >= 0) continue; if (!Object.prototype.propertyIsEnumerable.call(source, key)) continue; target[key] = source[key]; } } return target; }\n\nfunction _objectWithoutPropertiesLoose(source, excluded) { if (source == null) return {}; var target = {}; var sourceKeys = Object.keys(source); var key, i; for (i = 0; i < sourceKeys.length; i++) { key = sourceKeys[i]; if (excluded.indexOf(key) >= 0) continue; target[key] = source[key]; } return target; }\n\n/* @jsxRuntime classic */\n\n/* @jsx mdx */\nvar _frontmatter = {\n  \"layout\": \"BlogPage\",\n  \"title\": \"Como criar um sistema de Swap estável AMM\",\n  \"description\": \"Nesse artigo iremos aprender a como criar um sistema de Swap estável AMM através de contrato inteligente.\",\n  \"image\": \"capa.jpg\",\n  \"tags\": [\"Avançado\", \"DeFi\"],\n  \"author\": [\"Matheus\"],\n  \"publishedAt\": \"23/07/2022\",\n  \"modifiedAt\": \"20220723\",\n  \"suburl\": \"sistema-de-swap-estavel-amm/\"\n};\nvar layoutProps = {\n  _frontmatter: _frontmatter\n};\nvar MDXLayout = \"wrapper\";\nreturn function MDXContent(_ref) {\n  var components = _ref.components,\n      props = _objectWithoutProperties(_ref, _excluded);\n\n  return mdx(MDXLayout, _extends({}, layoutProps, props, {\n    components: components,\n    mdxType: \"MDXLayout\"\n  }), mdx(\"p\", null, \"Nesse artigo iremos aprender a como criar um sistema de Swap est\\xE1vel AMM atrav\\xE9s de contrato inteligente.\"), mdx(\"h2\", {\n    \"id\": \"sistema-de-swap-estável-amm\"\n  }, \"Sistema de Swap est\\xE1vel AMM\"), mdx(\"p\", null, \"Vers\\xE3o simplificada do AMM de swap est\\xE1vel da Curve\"), mdx(\"p\", null, mdx(\"strong\", {\n    parentName: \"p\"\n  }, \"Como funciona?\"), mdx(\"br\", null), \"\\nInvariante - pre\\xE7o de negocia\\xE7\\xE3o e quantidade de liquidez s\\xE3o determinados por esta equa\\xE7\\xE3o.\"), mdx(\"p\", null, \"An^n soma(x_i) + D = ADn^n + D^(n + 1) / (n^n prod(x_i))\"), mdx(\"p\", null, \"T\\xF3picos:\", mdx(\"br\", null), \"\\n0. M\\xE9todo de Newton x_(n + 1) = x_n - f(x_n) / f'(x_n)\"), mdx(\"ol\", null, mdx(\"li\", {\n    parentName: \"ol\"\n  }, \"Invariante\"), mdx(\"li\", {\n    parentName: \"ol\"\n  }, \"Trocar\", mdx(\"ul\", {\n    parentName: \"li\"\n  }, mdx(\"li\", {\n    parentName: \"ul\"\n  }, \"Calcular Y\"), mdx(\"li\", {\n    parentName: \"ul\"\n  }, \"Calcular D\"))), mdx(\"li\", {\n    parentName: \"ol\"\n  }, \"Obtenha o pre\\xE7o virtual\"), mdx(\"li\", {\n    parentName: \"ol\"\n  }, \"Adicione liquidez\", mdx(\"ul\", {\n    parentName: \"li\"\n  }, mdx(\"li\", {\n    parentName: \"ul\"\n  }, \"Taxa de desequil\\xEDbrio\"))), mdx(\"li\", {\n    parentName: \"ol\"\n  }, \"Remova a liquidez\"), mdx(\"li\", {\n    parentName: \"ol\"\n  }, \"Remova um token de liquidez\", mdx(\"ul\", {\n    parentName: \"li\"\n  }, mdx(\"li\", {\n    parentName: \"ul\"\n  }, \"Calcular retirar um token\"), mdx(\"li\", {\n    parentName: \"ul\"\n  }, \"getYD\")))), mdx(\"pre\", null, mdx(\"code\", {\n    parentName: \"pre\",\n    \"className\": \"language-js\"\n  }, \"// SPDX-License-Identifier: MIT\\npragma solidity ^0.8;\\n\\nlibrary Math {\\n    function abs(uint x, uint y) internal pure returns (uint) {\\n        return x >= y ? x - y : y - x;\\n    }\\n}\\n\\ncontract StableSwap {\\n    // N\\xFAmero de tokens\\n    uint private constant N = 3;\\n    // Coeficiente de amplifica\\xE7\\xE3o multiplicado por N^(N - 1)\\n    // Maior valor torna a curva mais plana\\n    // O valor mais baixo torna a curva mais parecida com um produto constante AMM\\n    uint private constant A = 1000 * (N**(N - 1));\\n    // 0.03%\\n    uint private constant SWAP_FEE = 300;\\n    // A taxa de liquidez \\xE9 derivada de 2 restri\\xE7\\xF5es:\\n    // 1. A taxa \\xE9 0 para adicionar/remover liquidez que resulta em um pool equilibrado\\n    // 2. Trocar em um pool equilibrado \\xE9 como adicionar e remover liquidez\\n    // de um pool balanceado\\n    // taxa de swap = adiciona taxa de liquidez + remove taxa de liquidez\\n    uint private constant LIQUIDITY_FEE = (SWAP_FEE * N) / (4 * (N - 1));\\n    uint private constant FEE_DENOMINATOR = 1e6;\\n\\n    address[N] public tokens;\\n    // Normalize cada token para 18 decimais\\n    // Exemplo - DAI (18 decimals), USDC (6 decimals), USDT (6 decimals)\\n    uint[N] private multipliers = [1, 1e12, 1e12];\\n    uint[N] public balances;\\n\\n    // 1 share = 1e18, 18 decimals\\n    uint private constant DECIMALS = 18;\\n    uint public totalSupply;\\n    mapping(address => uint) public balanceOf;\\n\\n    function _mint(address _to, uint _amount) private {\\n        balanceOf[_to] += _amount;\\n        totalSupply += _amount;\\n    }\\n\\n    function _burn(address _from, uint _amount) private {\\n        balanceOf[_from] -= _amount;\\n        totalSupply -= _amount;\\n    }\\n\\n    // Retorna saldos ajustados com precis\\xE3o, ajustados para 18 casas decimais\\n    function _xp() private view returns (uint[N] memory xp) {\\n        for (uint i; i < N; ++i) {\\n            xp[i] = balances[i] * multipliers[i];\\n        }\\n    }\\n\\n    /**\\n     * @notice Calcule D, soma dos saldos em um pool perfeitamente equilibrado\\n     * Se os saldos de x_0, x_1, ... x_(n-1) ent\\xE3o soma(x_i) = D\\n     * @param xp Saldos ajustados com precis\\xE3o\\n     * @return D\\n     */\\n    function _getD(uint[N] memory xp) private pure returns (uint) {\\n        /*\\n        O m\\xE9todo de Newton para calcular D\\n        -----------------------------\\n        f(D) = ADn^n + D^(n + 1) / (n^n prod(x_i)) - An^n sum(x_i) - D \\n        f'(D) = An^n + (n + 1) D^n / (n^n prod(x_i)) - 1\\n\\n                     (as + np)D_n\\n        D_(n+1) = -----------------------\\n                  (a - 1)D_n + (n + 1)p\\n\\n        a = An^n\\n        s = sum(x_i)\\n        p = (D_n)^(n + 1) / (n^n prod(x_i))\\n        */\\n        uint a = A * N; // An^n\\n\\n        uint s; // x_0 + x_1 + ... + x_(n-1)\\n        for (uint i; i < N; ++i) {\\n            s += xp[i];\\n        }\\n\\n        // O m\\xE9todo de Newton\\n        // Suposi\\xE7\\xE3o inicial, d <= s\\n        uint d = s;\\n        uint d_prev;\\n        for (uint i; i < 255; ++i) {\\n            // p = D^(n + 1) / (n^n * x_0 * ... * x_(n-1))\\n            uint p = d;\\n            for (uint j; j < N; ++j) {\\n                p = (p * d) / (N * xp[j]);\\n            }\\n            d_prev = d;\\n            d = ((a * s + N * p) * d) / ((a - 1) * d + (N + 1) * p);\\n\\n            if (Math.abs(d, d_prev) <= 1) {\\n                return d;\\n            }\\n        }\\n        revert(\\\"D n\\xE3o convergiu\\\");\\n    }\\n\\n    /**\\n    * @notice Calcule o novo saldo do token j dado o novo saldo do token i\\n    * @param i \\xCDndice do token de entrada\\n    * @param j \\xCDndice de token de sa\\xEDda\\n    * @param x Novo saldo do token i\\n    * @param xp Saldos atuais ajustados com precis\\xE3o\\n     */\\n    function _getY(\\n        uint i,\\n        uint j,\\n        uint x,\\n        uint[N] memory xp\\n    ) private pure returns (uint) {\\n        /*\\n        M\\xE9todo de Newton para calcular y\\n        -----------------------------\\n        y = x_j\\n\\n        f(y) = y^2 + y(b - D) - c\\n\\n                    y_n^2 + c\\n        y_(n+1) = --------------\\n                   2y_n + b - D\\n\\n        onde\\n        s = sum(x_k), k != j\\n        p = prod(x_k), k != j\\n        b = s + D / (An^n)\\n        c = D^(n + 1) / (n^n * p * An^n)\\n        */\\n        uint a = A * N;\\n        uint d = _getD(xp);\\n        uint s;\\n        uint c = d;\\n\\n        uint _x;\\n        for (uint k; k < N; ++k) {\\n            if (k == i) {\\n                _x = x;\\n            } else if (k == j) {\\n                continue;\\n            } else {\\n                _x = xp[k];\\n            }\\n\\n            s += _x;\\n            c = (c * d) / (N * _x);\\n        }\\n        c = (c * d) / (N * a);\\n        uint b = s + d / a;\\n\\n        // O m\\xE9todo de Newton\\n        uint y_prev;\\n        // Suposi\\xE7\\xE3o inicial, y <= d\\n        uint y = d;\\n        for (uint _i; _i < 255; ++_i) {\\n            y_prev = y;\\n            y = (y * y + c) / (2 * y + b - d);\\n            if (Math.abs(y, y_prev) <= 1) {\\n                return y;\\n            }\\n        }\\n        revert(\\\"vc n\\xE3o convergiu\\\");\\n    }\\n\\n    /**\\n    * @notice Calcule o novo saldo do token i dado ajustado com precis\\xE3o\\n    * saldos xp e liquidez d\\n    * @dev Equa\\xE7\\xE3o \\xE9 calcular y \\xE9 igual a _getY\\n    * @param i \\xCDndice do token para calcular o novo saldo\\n    * @param xp Saldos ajustados com precis\\xE3o\\n    * @param d Liquidez d\\n    * @return Novo saldo do token i\\n     */\\n    function _getYD(\\n        uint i,\\n        uint[N] memory xp,\\n        uint d\\n    ) private pure returns (uint) {\\n        uint a = A * N;\\n        uint s;\\n        uint c = d;\\n\\n        uint _x;\\n        for (uint k; k < N; ++k) {\\n            if (k != i) {\\n                _x = xp[k];\\n            } else {\\n                continue;\\n            }\\n\\n            s += _x;\\n            c = (c * d) / (N * _x);\\n        }\\n        c = (c * d) / (N * a);\\n        uint b = s + d / a;\\n\\n        // O m\\xE9todo de Newton\\n        uint y_prev;\\n        // Suposi\\xE7\\xE3o inicial, y <= d\\n        uint y = d;\\n        for (uint _i; _i < 255; ++_i) {\\n            y_prev = y;\\n            y = (y * y + c) / (2 * y + b - d);\\n            if (Math.abs(y, y_prev) <= 1) {\\n                return y;\\n            }\\n        }\\n        revert(\\\"vc n\\xE3o convergiu\\\");\\n    }\\n\\n    // Valor estimado de 1 a\\xE7\\xE3o\\n    // Quantos tokens vale uma a\\xE7\\xE3o?\\n    function getVirtualPrice() external view returns (uint) {\\n        uint d = _getD(_xp());\\n        uint _totalSupply = totalSupply;\\n        if (_totalSupply > 0) {\\n            return (d * 10**DECIMALS) / _totalSupply;\\n        }\\n        return 0;\\n    }\\n\\n    /**\\n    * @notice Troque a quantidade dx do token i pelo token j\\n    * @param i \\xCDndice do token em\\n    * @param j \\xCDndice de token out\\n    * @param dx Token em quantidade\\n    * @param minDy Sa\\xEDda m\\xEDnima do token\\n     */\\n    function swap(\\n        uint i,\\n        uint j,\\n        uint dx,\\n        uint minDy\\n    ) external returns (uint dy) {\\n        require(i != j, \\\"i = j\\\");\\n\\n        IERC20(tokens[i]).transferFrom(msg.sender, address(this), dx);\\n\\n        // Calcula dy\\n        uint[N] memory xp = _xp();\\n        uint x = xp[i] + dx * multipliers[i];\\n\\n        uint y0 = xp[j];\\n        uint y1 = _getY(i, j, x, xp);\\n        // y0 deve ser >= y1, pois x aumentou\\n        // -1 para arredondar para baixo\\n        dy = (y0 - y1 - 1) / multipliers[j];\\n\\n        // Subtrair taxa (fee) de dy\\n        uint fee = (dy * SWAP_FEE) / FEE_DENOMINATOR;\\n        dy -= fee;\\n        require(dy >= minDy, \\\"dy < min\\\");\\n\\n        balances[i] += dx;\\n        balances[j] -= dy;\\n\\n        IERC20(tokens[j]).transfer(msg.sender, dy);\\n    }\\n\\n    function addLiquidity(uint[N] calldata amounts, uint minShares)\\n        external\\n        returns (uint shares)\\n    {\\n        // calcular a liquidez atual d0\\n        uint _totalSupply = totalSupply;\\n        uint d0;\\n        uint[N] memory old_xs = _xp();\\n        if (_totalSupply > 0) {\\n            d0 = _getD(old_xs);\\n        }\\n\\n        // Transferir tokens em\\n        uint[N] memory new_xs;\\n        for (uint i; i < N; ++i) {\\n            uint amount = amounts[i];\\n            if (amount > 0) {\\n                IERC20(tokens[i]).transferFrom(msg.sender, address(this), amount);\\n                new_xs[i] = old_xs[i] + amount * multipliers[i];\\n            } else {\\n                new_xs[i] = old_xs[i];\\n            }\\n        }\\n\\n        // Calcular nova liquidez d1\\n        uint d1 = _getD(new_xs);\\n        require(d1 > d0, \\\"a liquidez n\\xE3o aumentou\\\");\\n\\n        // Recalcular D contabilizando a taxa de desequil\\xEDbrio\\n        uint d2;\\n        if (_totalSupply > 0) {\\n            for (uint i; i < N; ++i) {\\n                // TODO: por que old_xs[i] * d1 / d0? por que n\\xE3o d1 / N?\\n                uint idealBalance = (old_xs[i] * d1) / d0;\\n                uint diff = Math.abs(new_xs[i], idealBalance);\\n                new_xs[i] -= (LIQUIDITY_FEE * diff) / FEE_DENOMINATOR;\\n            }\\n\\n            d2 = _getD(new_xs);\\n        } else {\\n            d2 = d1;\\n        }\\n\\n        // Atualizar saldos\\n        for (uint i; i < N; ++i) {\\n            balances[i] += amounts[i];\\n        }\\n\\n        // Shares para cunhar = (d2 - d0) / d0 * total supply\\n        // d1 >= d2 >= d0\\n        if (_totalSupply > 0) {\\n            shares = ((d2 - d0) * _totalSupply) / d0;\\n        } else {\\n            shares = d2;\\n        }\\n        require(shares >= minShares, \\\"shares < min\\\");\\n        _mint(msg.sender, shares);\\n    }\\n\\n    function removeLiquidity(uint shares, uint[N] calldata minAmountsOut)\\n        external\\n        returns (uint[N] memory amountsOut)\\n    {\\n        uint _totalSupply = totalSupply;\\n\\n        for (uint i; i < N; ++i) {\\n            uint amountOut = (balances[i] * shares) / _totalSupply;\\n            require(amountOut >= minAmountsOut[i], \\\"amountOut < min\\\");\\n\\n            balances[i] -= amountOut;\\n            amountsOut[i] = amountOut;\\n\\n            IERC20(tokens[i]).transfer(msg.sender, amountOut);\\n        }\\n\\n        _burn(msg.sender, shares);\\n    }\\n\\n    /**\\n    * @notice Calcular a quantidade de token i para receber por a\\xE7\\xF5es\\n    * @param shares A\\xE7\\xF5es para queimar\\n    * @param i \\xCDndice do token a ser retirado\\n    * @return dy Quantidade de token i a receber\\n    *         fee: Taxa para retirada. Taxa j\\xE1 inclu\\xEDda no dy\\n     */\\n    function _calcWithdrawOneToken(uint shares, uint i)\\n        private\\n        view\\n        returns (uint dy, uint fee)\\n    {\\n        uint _totalSupply = totalSupply;\\n        uint[N] memory xp = _xp();\\n\\n        // Calcule d0 e d1\\n        uint d0 = _getD(xp);\\n        uint d1 = d0 - (d0 * shares) / _totalSupply;\\n\\n        // Calcule a redu\\xE7\\xE3o em y se D = d1\\n        uint y0 = _getYD(i, xp, d1);\\n        // d1 <= d0 ent\\xE3o vc deve ser <= xp[i]\\n        uint dy0 = (xp[i] - y0) / multipliers[i];\\n\\n        // Calcule a taxa de desequil\\xEDbrio, atualize o xp com taxas\\n        uint dx;\\n        for (uint j; j < N; ++j) {\\n            if (j == i) {\\n                dx = (xp[j] * d1) / d0 - y0;\\n            } else {\\n                // d1 / d0 <= 1\\n                dx = xp[j] - (xp[j] * d1) / d0;\\n            }\\n            xp[j] -= (LIQUIDITY_FEE * dx) / FEE_DENOMINATOR;\\n        }\\n\\n        // Recalcular y com xp incluindo taxas de desequil\\xEDbrio\\n        uint y1 = _getYD(i, xp, d1);\\n        // - 1 arredondar para baixo\\n        dy = (xp[i] - y1 - 1) / multipliers[i];\\n        fee = dy0 - dy;\\n    }\\n\\n    function calcWithdrawOneToken(uint shares, uint i)\\n        external\\n        view\\n        returns (uint dy, uint fee)\\n    {\\n        return _calcWithdrawOneToken(shares, i);\\n    }\\n\\n    /**\\n    * @notice Retirar liquidez no token i\\n    * @param shares A\\xE7\\xF5es para queimar\\n    * @param i Token para retirar\\n    * @param minAmountOut Quantidade m\\xEDnima de token i que deve ser retirada\\n     */\\n    function removeLiquidityOneToken(\\n        uint shares,\\n        uint i,\\n        uint minAmountOut\\n    ) external returns (uint amountOut) {\\n        (amountOut, ) = _calcWithdrawOneToken(shares, i);\\n        require(amountOut >= minAmountOut, \\\"amountOut < min\\\");\\n\\n        balances[i] -= amountOut;\\n        _burn(msg.sender, shares);\\n\\n        IERC20(tokens[i]).transfer(msg.sender, amountOut);\\n    }\\n}\\n\\ninterface IERC20 {\\n    function totalSupply() external view returns (uint);\\n\\n    function balanceOf(address account) external view returns (uint);\\n\\n    function transfer(address recipient, uint amount) external returns (bool);\\n\\n    function allowance(address owner, address spender) external view returns (uint);\\n\\n    function approve(address spender, uint amount) external returns (bool);\\n\\n    function transferFrom(\\n        address sender,\\n        address recipient,\\n        uint amount\\n    ) external returns (bool);\\n\\n    event Transfer(address indexed from, address indexed to, uint amount);\\n    event Approval(address indexed owner, address indexed spender, uint amount);\\n}\\n\")), mdx(\"br\", null), mdx(\"h3\", {\n    \"id\": \"testar-no-remix\"\n  }, \"Testar no \", mdx(\"a\", {\n    parentName: \"h3\",\n    \"href\": \"https://remix.ethereum.org/\",\n    \"target\": \"_blank\",\n    \"rel\": \"noopener\"\n  }, \"Remix\")), mdx(\"br\", null), mdx(\"br\", null));\n}\n;\nMDXContent.isMDXComponent = true;","frontmatter":{"title":"Como criar um sistema de Swap estável AMM","description":"Nesse artigo iremos aprender a como criar um sistema de Swap estável AMM através de contrato inteligente.","image":{"childImageSharp":{"fluid":{"base64":"data:image/jpeg;base64,/9j/2wBDABALDA4MChAODQ4SERATGCgaGBYWGDEjJR0oOjM9PDkzODdASFxOQERXRTc4UG1RV19iZ2hnPk1xeXBkeFxlZ2P/2wBDARESEhgVGC8aGi9jQjhCY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2NjY2P/wgARCAANABQDASIAAhEBAxEB/8QAGAAAAgMAAAAAAAAAAAAAAAAAAAQBAgP/xAAUAQEAAAAAAAAAAAAAAAAAAAAA/9oADAMBAAIQAxAAAAFxjYJLB//EABoQAAICAwAAAAAAAAAAAAAAAAISAREEECH/2gAIAQEAAQUCGayDeBG1WG7r/8QAFBEBAAAAAAAAAAAAAAAAAAAAEP/aAAgBAwEBPwE//8QAFBEBAAAAAAAAAAAAAAAAAAAAEP/aAAgBAgEBPwE//8QAHRAAAgICAwEAAAAAAAAAAAAAAREAAjFRAxASYf/aAAgBAQAGPwIg8hNrNDUJDt8geZ6Ce5nr/8QAGxAAAgIDAQAAAAAAAAAAAAAAAREAIRAxQfH/2gAIAQEAAT8hZSCOghPsHFOERBSWIQIB2lmLzx//2gAMAwEAAgADAAAAEMDP/8QAFBEBAAAAAAAAAAAAAAAAAAAAEP/aAAgBAwEBPxA//8QAFBEBAAAAAAAAAAAAAAAAAAAAEP/aAAgBAgEBPxA//8QAIBABAQABAQkAAAAAAAAAAAAAAREAIRAxQVFhgZHR4f/aAAgBAQABPxAavgac0E4PrrjMj0mvLGIMFJR7aZcVaQw5Xfgnz2f/2Q==","aspectRatio":1.5151515151515151,"src":"/static/20d3cc15810bf9257fb175a4ee49d2bc/0cb3d/capa.jpg","srcSet":"/static/20d3cc15810bf9257fb175a4ee49d2bc/f836f/capa.jpg 200w,\n/static/20d3cc15810bf9257fb175a4ee49d2bc/2244e/capa.jpg 400w,\n/static/20d3cc15810bf9257fb175a4ee49d2bc/0cb3d/capa.jpg 536w","sizes":"(max-width: 536px) 100vw, 536px"}}},"tags":["Avançado","DeFi"],"author":["Matheus"],"suburl":"sistema-de-swap-estavel-amm/","publishedAt":"23/07/2022","modifiedAt":"20220723"},"tableOfContents":{"items":[{"url":"#sistema-de-swap-estável-amm","title":"Sistema de Swap estável AMM","items":[{"url":"#testar-no-remix","title":"Testar no Remix"}]}]},"timeToRead":1},"allMdx":{"nodes":[{"frontmatter":{"suburl":"sistema-de-swap-estavel-amm/","title":"Como criar um sistema de Swap estável AMM","tags":["Avançado","DeFi"]}},{"frontmatter":{"suburl":"produto-constante-amm/","title":"Como criar um produto constante AMM","tags":["Intermediário","DeFi"]}},{"frontmatter":{"suburl":"soma-constante-amm/","title":"Como criar uma soma constante AMM","tags":["Intermediário","DeFi"]}},{"frontmatter":{"suburl":"sistema-de-cofre/","title":"Como criar um sistema de Cofre","tags":["Intermediário","DeFi"]}},{"frontmatter":{"suburl":"sistema-de-staking/","title":"Como criar um sistema de Staking de Recompensas","tags":["Intermediário","Avançado","DeFi"]}},{"frontmatter":{"suburl":"sistema-de-preco-chainlink-oracle/","title":"Como criar um sistema de preços Oracle","tags":["Intermediário","Avançado","DeFi"]}},{"frontmatter":{"suburl":"exemplos-de-uso-do-uniswap-v3/","title":"Exemplos de uso do Uniswap V3","tags":["Intermediário","Avançado","DeFi"]}},{"frontmatter":{"suburl":"fornecimento-unilateral-com-uniswap-v2/","title":"Fornecimento unilateral ideal com Uniswap V2","tags":["Intermediário","Avançado","DeFi"]}},{"frontmatter":{"suburl":"adicionar-e-remover-liquidez-com-uniswap-v2/","title":"Como adicionar e remover liquidez com Uniswap V2","tags":["Intermediário","Avançado","DeFi"]}},{"frontmatter":{"suburl":"swap-com-uniswap-v2/","title":"Como realizar Swap com Uniswap V2","tags":["Intermediário","DeFi"]}},{"frontmatter":{"suburl":"testes-com-echidna/","title":"Como realizar testes com Echidna","tags":["Intermediário"]}},{"frontmatter":{"suburl":"ignorar-verificacao-do-tamanho-do-contrato/","title":"Como ignorar a verificação do tamanho do contrato","tags":["Intermediário","Hacks"]}},{"frontmatter":{"suburl":"repeticao-de-assinatura/","title":"Repetição de assinatura","tags":["Avançado","Hacks"]}},{"frontmatter":{"suburl":"manipular-timestamp-do-bloco/","title":"Manipulando o timestamp do bloco na blockchain","tags":["Intermediário","Hacks"]}},{"frontmatter":{"suburl":"ataque-front-running/","title":"Ataque utilizando a técnica front running","tags":["Intermediário","Hacks"]}},{"frontmatter":{"suburl":"honeypot/","title":"Criar uma armadilha para hackers com a técnica honeypot","tags":["Intermediário","Hacks"]}},{"frontmatter":{"suburl":"ocultar-script-malicioso/","title":"Como um contrato malicioso esconde seu script","tags":["Intermediário","Hacks"]}},{"frontmatter":{"suburl":"phishing-com-txorigin/","title":"Phishing com tx.origin","tags":["Intermediário","Hacks"]}},{"frontmatter":{"suburl":"negacao-de-servico/","title":"Inutilizar um contrato através da negação de serviço","tags":["Intermediário","Hacks"]}},{"frontmatter":{"suburl":"fonte-de-aleatoriedade/","title":"Fonte de Aleatoriedade","tags":["Intermediário","Hacks"]}},{"frontmatter":{"suburl":"chamada-de-funcao-delegatecall/","title":"Chamada de função delegatecall","tags":["Intermediário","Hacks"]}},{"frontmatter":{"suburl":"acessando-variaveis-privadas/","title":"Acessando variáveis privadas","tags":["Intermediário","Hacks"]}},{"frontmatter":{"suburl":"auto-destruicao/","title":"Ataques com Auto-destruição","tags":["Intermediário","Hacks"]}},{"frontmatter":{"suburl":"estouro-de-memoria/","title":"Ataques com estouro de memória","tags":["Intermediário","Hacks"]}},{"frontmatter":{"suburl":"ataque-de-reentrada/","title":"Ataque de reentrada, aprenda como funciona e como evitar","tags":["Intermediário","Hacks"]}},{"frontmatter":{"suburl":"bloqueio-de-tempo-timelock/","title":"Criar um contrato com bloqueio de tempo","tags":["Avançado","Aplicações"]}},{"frontmatter":{"suburl":"contrato-para-multichamadas/","title":"Criar contrato para Multichamada de funções","tags":["Avançado","Aplicações"]}},{"frontmatter":{"suburl":"financiamento-coletivo-crowd-fund/","title":"Criar um sistema de financiamento coletivo","tags":["Avançado","Aplicações"]}},{"frontmatter":{"suburl":"sistema-de-leilao-ingles-holandes/","title":"Criar um sistema de leilão inglês e holandês","tags":["Avançado","Aplicações"]}},{"frontmatter":{"suburl":"canal-de-pagamento-bidirecional/","title":"Criar um Canal de pagamento bidirecional","tags":["Avançado","Aplicações"]}},{"frontmatter":{"suburl":"canal-de-pagamento-unidirecional/","title":"Criar um Canal de pagamento unidirecional","tags":["Avançado","Aplicações"]}},{"frontmatter":{"suburl":"gravar-dados-no-slot/","title":"Como gravar dados em qualquer slot","tags":["Intermediário","Aplicações"]}},{"frontmatter":{"suburl":"implantar-contrato-com-proxy/","title":"Como implantar qualquer contrato com Proxy","tags":["Avançado","Aplicações"]}},{"frontmatter":{"suburl":"trabalhando-com-proxy/","title":"Trabalhando com Proxy","tags":["Avançado","Aplicações"]}},{"frontmatter":{"suburl":"precomputar-endereco-contrato/","title":"Pré-computar endereço do Contrato com Create2","tags":["Avançado","Aplicações"]}},{"frontmatter":{"suburl":"token-erc721/","title":"Criando nosso primeiro Token ERC721","tags":["Intermediário","Avançado","Aplicações"]}},{"frontmatter":{"suburl":"token-erc20/","title":"Criando nosso primeiro Token ERC20","tags":["Intermediário","Avançado","Aplicações"]}},{"frontmatter":{"suburl":"aplicacao-mapeamento-iteravel/","title":"Mapeamento Iterável","tags":["Intermediário","Aplicações"]}},{"frontmatter":{"suburl":"aplicacao-arvore-merkle/","title":"Árvore de Merkle","tags":["Avançado","Aplicações"]}},{"frontmatter":{"suburl":"aplicacao-multi-assinatura/","title":"Carteira com Multi-Assinaturas","tags":["Intermediário","Avançado","Aplicações"]}},{"frontmatter":{"suburl":"aplicacao-wallet/","title":"Carteira de Tokens","tags":["Iniciante","Aplicações"]}},{"frontmatter":{"suburl":"assinaturas-e-hashing-keccak/","title":"Verificando assinatura hashing com Keccak256","tags":["Intermediário","Avançado"]}},{"frontmatter":{"suburl":"abi/","title":"O que é ABI e para que serve?","tags":["Iniciante"]}},{"frontmatter":{"suburl":"import-e-libraries/","title":"Import e Libraries, para que servem?","tags":["Iniciante","Intermediário"]}},{"frontmatter":{"suburl":"criar-contrato-simples/","title":"Criar um contrato através de outro contrato","tags":["Intermediário"]}},{"frontmatter":{"suburl":"call-fallback-delegatecall/","title":"Call, Fallback, Delegatecall e chamadas de contratos","tags":["Intermediário"]}},{"frontmatter":{"suburl":"transfer-send-call/","title":"Enviar Ether com transfer, send e call","tags":["Iniciante","Intermediário"]}},{"frontmatter":{"suburl":"visibilidade-interface-pagavel/","title":"Visibilidade, Interfaces e Funções Pagáveis","tags":["Intermediário"]}},{"frontmatter":{"suburl":"evento-construtor-heranca/","title":"Evento, Construtor e Herança","tags":["Iniciante","Intermediário"]}},{"frontmatter":{"suburl":"tratamento-de-erros/","title":"Tratamento de erros de condições e exceções","tags":["Iniciante","Intermediário"]}},{"frontmatter":{"suburl":"funcoes/","title":"Funções e Modificadores","tags":["Iniciante","Intermediário"]}},{"frontmatter":{"suburl":"armazenamento/","title":"Armazenamento de Dados","tags":["Intermediário"]}},{"frontmatter":{"suburl":"estruturas/","title":"Estruturas - Struct","tags":["Iniciante","Intermediário"]}},{"frontmatter":{"suburl":"enum/","title":"Enum - Enumeradores","tags":["Iniciante","Intermediário"]}},{"frontmatter":{"suburl":"mapping-arrays/","title":"Mapping e Arrays","tags":["Iniciante"]}},{"frontmatter":{"suburl":"if-else-for-while/","title":"If, Else, For e While","tags":["Iniciante"]}},{"frontmatter":{"suburl":"ether-wei-gas/","title":"Ether, Wei e Taxa de Gas","tags":["Iniciante"]}},{"frontmatter":{"suburl":"variaveis/","title":"Entendendo as Variáveis","tags":["Iniciante"]}},{"frontmatter":{"suburl":"primeiro-aplicativo/","title":"Meu primeiro aplicativo","tags":["Iniciante","Aplicações"]}}]},"topicsYaml":{"topics":[{"desc":"Todos os conteúdos de nível iniciante estão disponíveis aqui","title":"Iniciante","url":"iniciante/"},{"desc":"Todos os conteúdos de nível intermediário estão disponíveis aqui","title":"Intermediário","url":"intermediario/"},{"desc":"Todos os conteúdos de nível avançado estão disponíveis aqui","title":"Avançado","url":"avancado/"},{"desc":"Todos os artigos referentes a exemplos de aplicações do Solidity, estão disponíveis aqui","title":"Aplicações","url":"aplicacoes/"},{"desc":"Todos os artigos referentes a exemplos de aplicação de hacks do Solidity, estão disponíveis aqui","title":"Hacks","url":"hacks/"},{"desc":"Todos os artigos referentes a exemplos de aplicação DeFi do Solidity, estão disponíveis aqui","title":"DeFi","url":"defi/"},{"desc":"Artigos de outras linguagens de programação, exemplos de interação entre a blockchain e aplicativos externos, estão disponíveis aqui","title":"Outros Artigos","url":"artigos/"}]}},"pageContext":{"suburl":"sistema-de-swap-estavel-amm/","postTopics":["Avançado","DeFi"],"publishedAt":"23/07/2022","prevArticle":{"title":"Como criar um produto constante AMM","layout":"BlogPage","suburl":"produto-constante-amm/","author":["Matheus"],"tags":["Intermediário","DeFi"],"publishedAt":"21/07/2022","modifiedAt":"20220721"},"nextArticle":null}},"staticQueryHashes":["119291576","2330562257","4065828390"]}